#include <atomic>
#include <cmath>
#include <chrono>
#include <imgui.h>
#include "辅助类.h"
#include "物资ID.h"
#include "图片调用.h"
#include <map>
#include <cmath>
#include <algorithm>
#include <unordered_map>
#include <cstdlib>
#include <vector>
#include <array>
#include <ctime>
#include <thread>
//#include <stop_token>

unordered_map<int, ImColor> colorMap;

std::map<std::string, int> Antitankgrenade; //给手雷一个机会,不然让你飞起来

 bool LineOfSightTo1 = true;

ImColor RandomColor()
{
  int R, G, B, A = 255;
  R = (random() % 255);
  G = (random() % 255);
  B = (random() % 255);
  return ImColor(R, G, B, A);
}
int dygl = 0;
ImColor GetRandomColorById(int id) {
  if (colorMap.find(id) != colorMap.end()) {
    return colorMap[id];
  } else {
    ImColor color = RandomColor();
    colorMap[id] = color;
    return color;
  }
}

const char* 绘制::Level(char *name) {
  if (strstr(name,"Lv1") != 0) {
    return "Lv1";
  }else if (strstr(name,"Lv2") != 0) {
    return "Lv2";
  }else if (strstr(name,"Lv3") != 0) {
    return "Lv3";
  }else if (strstr(name,"Lv4") != 0) {
    return "Lv4";
  }else if (strstr(name,"Lv5") != 0) {
    return "Lv5";
  }else if (strstr(name,"Lv6") != 0) {
    return "Lv6";
  }else if (strstr(name,"Lv7") != 0) {
    return "Lv7";
  }
  return "未知";
}




void 绘制::保存配置() {  
  std::string 配置;
  配置 += "自瞄范围:"+ std::to_string(自瞄.自瞄范围) + ";\n";
  配置 += "触摸范围:"+ std::to_string(自瞄.触摸范围) + ";\n";
  配置 += "自瞄速度:"+ std::to_string(自瞄.自瞄速度) + ";\n";
  配置 += "压枪力度:"+ std::to_string(自瞄.压枪力度) + ";\n";
  配置 += "预判力度:"+ std::to_string(自瞄.预判力度) + ";\n";
  配置 += "雷达X:"+ std::to_string(按钮.雷达X) + ";\n";
  配置 += "雷达Y:"+ std::to_string(按钮.雷达Y) + ";\n";
  配置 += "趴下位置调节:"+ std::to_string(自瞄.趴下位置调节) + ";\n";
  配置 += "触摸采样率:"+ std::to_string(自瞄.触摸采样率) + ";\n";
  配置 += "喷子距离限制:"+ std::to_string(自瞄.喷子距离限制) + ";\n";
  配置 += "掉血自瞄数率:"+ std::to_string(自瞄.掉血自瞄数率) + ";\n";
  
  配置 += "腰射距离限制:"+ std::to_string(自瞄.腰射距离限制) + ";\n";
  配置 += "自瞄距离限制:"+ std::to_string(自瞄.自瞄距离限制) + ";\n";
    
  配置 += "触摸范围X:"+ std::to_string(自瞄.触摸范围X) + ";\n";
  配置 += "触摸范围Y:"+ std::to_string(自瞄.触摸范围Y) + ";\n";
  
  配置 += "雷达X:"+ std::to_string(按钮.雷达X) + ";\n";
  配置 += "雷达Y:"+ std::to_string(按钮.雷达Y) + ";\n";
  配置 += "方框粗细:"+ std::to_string(按钮.方框粗细) + ";\n";
  配置 += "射线粗细:"+ std::to_string(按钮.射线粗细) + ";\n";
  配置 += "骨骼粗细:"+ std::to_string(按钮.骨骼粗细) + ";\n";
  
  std::ofstream outputFile("/data/local/tmp/三级头ImGui自瞄配置", ios::out | ios::trunc);
  outputFile << 配置;
  outputFile.close();
  
  
  string SaveFile = "/data";
  SaveFile += "/";
  SaveFile += "颜色三级头ImGui自瞄配置";
  numSave = fopen(SaveFile.c_str(), "wb+");
  fseek(numSave, 0, SEEK_SET);
  fwrite(Colorset, sizeof(ColorTable), 2, numSave);
  fwrite(static_cast<void*>(&自瞄.初始化), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&自瞄.掉血自瞄), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&自瞄.狙击自瞄), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&自瞄.喷子自瞄), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&自瞄.动态自瞄), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&自瞄.隐藏自瞄圈), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&自瞄.随机触摸点), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&自瞄.准星射线), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&自瞄.倒地不瞄), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&自瞄.人机不瞄), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&自瞄.自瞄条件), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&自瞄.瞄准优先), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&自瞄.瞄准部位), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&自瞄.掉血自瞄数率), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&自瞄.喷子自瞄条件), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&自瞄.充电口方向), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.人数), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.方框), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.血量), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.手持), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.盒子), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.空投), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.背敌预警), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.距离), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.射线), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.名字), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.骨骼), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.车辆), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.雷达), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.手雷预警), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.忽略人机), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.被瞄), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.金仓), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.物资总开关), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.信号枪), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.电竞信号枪), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.召回信号枪), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.圣诞信号枪), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.夏日信号枪), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.盔仔信号枪), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.蜜罐), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.M762), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.VAL), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.G63C), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.Famas), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.狗砸), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.AKM), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.QBZ), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.MK47), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.AUG), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.M16A4), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.SCAR), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.M416), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.十字弩), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.AWM), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.kar98k), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.M24), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.Mini14), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.Win94), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.SLR), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.AMR), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.M417), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.MK20), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.MK12), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.QBU), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.SKS), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.MK14), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.M200), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.莫辛纳甘), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.爆炸猎弓), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.VSS), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.DP28), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.M249), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.PKM), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.MG3), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.P90), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.MP5K), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.野牛), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.UMP9), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.维克托), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.汤姆逊), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.UZI), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.S12K), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.S1897), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.双管猎枪), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.DBS), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.SPAS), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.AA12), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.短管散弹枪), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.R1895), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.R45双持), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.沙漠之鹰), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.TMP9), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.蝎式手枪), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.P18C), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.R1911), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.P92), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.平底锅), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.镰刀), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.撬棍), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.大砍刀), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.盾牌), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.燃烧瓶), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.烟雾弹), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.震爆弹), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.手榴弹), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.烟雾榴弹), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.一级甲), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.二级甲), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.三级甲), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.一级头), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.二级头), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.三级头), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.一级包), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.二级包), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.三级包), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.吉利服), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.吉利服1), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.汽油), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.医疗箱), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.急救包), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.绷带), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.可乐), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.肾上腺素), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.止痛药), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.自救器), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.马格南), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.A762), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.A556), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.A9毫米), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.A12口径), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.A45口径), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.A57MM), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.A50口径), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.信号枪子弹), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.箭矢), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.红点), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.全息), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.二倍镜), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.三倍镜), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.四倍镜), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.六倍镜), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.八倍镜), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.侧面镜), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.战术瞄准镜), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.子弹袋), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.箭袋), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.激光瞄准镜), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.轻型握把), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.半载握把), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.UZI枪托), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.狙击枪托), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.步枪枪托), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.狙击补偿器), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.狙击枪消焰器), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.狙击枪消音器), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.步枪消音器), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.步枪补偿器), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.步枪消焰器), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.冲锋枪消音器), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.冲锋枪消焰器), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.拇指握把), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.垂直握把), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.直角握把), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.撞火枪托), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.霰弹快速), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.鸭嘴枪口), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.霰弹收束), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.狙击枪快扩), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.狙击枪扩容), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.狙击枪快速), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.步枪快扩), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.步枪扩容), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.步枪快速), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.冲锋枪快扩), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.冲锋枪扩容), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.冲锋枪快速), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.手枪快扩), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.手枪快速), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.手枪扩容), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.绘制武器箱), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.绘制药箱), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.绘制宝箱), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.军事宝箱), sizeof(bool), 1, numSave);
  fwrite(static_cast<void*>(&按钮.海盗福利箱), sizeof(bool), 1, numSave);
  
  fflush(numSave);
  fsync(fileno(numSave));
  fclose(numSave);  
}

void 绘制::读取配置() {
  std::ifstream inputFile("/data/local/tmp/三级头ImGui自瞄配置");
  std::string line;
  while (std::getline(inputFile, line)) {
    if (line.find("自瞄范围:") != std::string::npos) {
      自瞄.自瞄范围 = std::stof(line.substr(line.find(":") + 1, line.find(";") - line.find(":") - 1));
    } else if (line.find("触摸范围:") != std::string::npos) {
      自瞄.触摸范围 = std::stof(line.substr(line.find(":") + 1, line.find(";") - line.find(":") - 1));
    } else if (line.find("自瞄速度:") != std::string::npos) {
      自瞄.自瞄速度 = std::stof(line.substr(line.find(":") + 1, line.find(";") - line.find(":") - 1));
    } else if (line.find("压枪力度:") != std::string::npos) {
      自瞄.压枪力度 = std::stof(line.substr(line.find(":") + 1, line.find(";") - line.find(":") - 1));
    } else if (line.find("预判力度:") != std::string::npos) {
      自瞄.预判力度 = std::stof(line.substr(line.find(":") + 1, line.find(";") - line.find(":") - 1));
    }else if (line.find("雷达X:") != std::string::npos) {
      按钮.雷达X = std::stof(line.substr(line.find(":") + 1, line.find(";") - line.find(":") - 1));
    }else if (line.find("雷达Y:") != std::string::npos) {
      按钮.雷达Y = std::stof(line.substr(line.find(":") + 1, line.find(";") - line.find(":") - 1));
    }else if (line.find("趴下位置调节:") != std::string::npos) {
      自瞄.趴下位置调节 = std::stof(line.substr(line.find(":") + 1, line.find(";") - line.find(":") - 1));
    }else if (line.find("触摸采样率:") != std::string::npos) {
      自瞄.触摸采样率 = std::stof(line.substr(line.find(":") + 1, line.find(";") - line.find(":") - 1));
    }else if (line.find("喷子距离限制:") != std::string::npos) {
      自瞄.喷子距离限制 = std::stof(line.substr(line.find(":") + 1, line.find(";") - line.find(":") - 1));
    }else if (line.find("掉血自瞄数率:") != std::string::npos) {
      自瞄.掉血自瞄数率 = std::stof(line.substr(line.find(":") + 1, line.find(";") - line.find(":") - 1));
    }else if (line.find("方框粗细:") != std::string::npos) {
      按钮.方框粗细 = std::stof(line.substr(line.find(":") + 1, line.find(";") - line.find(":") - 1));
    }else if (line.find("射线粗细:") != std::string::npos) {
      按钮.射线粗细 = std::stof(line.substr(line.find(":") + 1, line.find(";") - line.find(":") - 1));
    }else if (line.find("骨骼粗细:") != std::string::npos) {
      按钮.骨骼粗细 = std::stof(line.substr(line.find(":") + 1, line.find(";") - line.find(":") - 1));
    }else if (line.find("触摸范围X:") != std::string::npos) {
      自瞄.触摸范围X = std::stof(line.substr(line.find(":") + 1, line.find(";") - line.find(":") - 1));
    }else if (line.find("触摸范围Y:") != std::string::npos) {
      自瞄.触摸范围Y = std::stof(line.substr(line.find(":") + 1, line.find(";") - line.find(":") - 1));
    }else if (line.find("自瞄距离限制:") != std::string::npos) {
      自瞄.自瞄距离限制 = std::stof(line.substr(line.find(":") + 1, line.find(";") - line.find(":") - 1));
    }else if (line.find("腰射距离限制:") != std::string::npos) {
      自瞄.腰射距离限制 = std::stof(line.substr(line.find(":") + 1, line.find(";") - line.find(":") - 1));
    }
  }
 
  string SaveFile = "/data";   
  SaveFile += "/";
  SaveFile += "颜色三级头ImGui自瞄配置";
  numSave = fopen(SaveFile.c_str(), "rb+");
  fseek(numSave, 0, SEEK_SET);
  fread(Colorset, sizeof(ColorTable), 2, numSave);
  fread(static_cast<void*>(&按钮.人数), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.方框), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.血量), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.手持), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.盒子), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.空投), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.背敌预警), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.距离), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.射线), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.名字), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.骨骼), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.车辆), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.雷达), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.手雷预警), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.忽略人机), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.被瞄), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.金仓), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.物资总开关), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.信号枪), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.电竞信号枪), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.召回信号枪), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.圣诞信号枪), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.夏日信号枪), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.盔仔信号枪), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.蜜罐), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.M762), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.VAL), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.G63C), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.Famas), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.狗砸), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.AKM), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.QBZ), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.MK47), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.AUG), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.M16A4), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.SCAR), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.M416), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.十字弩), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.AWM), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.kar98k), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.M24), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.Mini14), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.Win94), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.SLR), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.AMR), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.M417), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.MK20), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.MK12), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.QBU), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.SKS), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.MK14), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.M200), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.莫辛纳甘), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.爆炸猎弓), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.VSS), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.DP28), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.M249), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.PKM), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.MG3), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.P90), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.MP5K), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.野牛), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.UMP9), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.维克托), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.汤姆逊), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.UZI), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.S12K), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.S1897), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.双管猎枪), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.DBS), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.SPAS), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.AA12), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.短管散弹枪), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.R1895), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.R45双持), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.沙漠之鹰), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.TMP9), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.蝎式手枪), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.P18C), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.R1911), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.P92), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.平底锅), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.镰刀), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.撬棍), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.大砍刀), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.盾牌), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.燃烧瓶), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.烟雾弹), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.震爆弹), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.手榴弹), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.烟雾榴弹), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.一级甲), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.二级甲), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.三级甲), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.一级头), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.二级头), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.三级头), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.一级包), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.二级包), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.三级包), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.吉利服), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.吉利服1), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.汽油), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.医疗箱), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.急救包), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.绷带), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.可乐), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.肾上腺素), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.止痛药), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.自救器), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.马格南), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.A762), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.A556), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.A9毫米), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.A12口径), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.A45口径), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.A57MM), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.A50口径), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.信号枪子弹), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.箭矢), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.红点), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.全息), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.二倍镜), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.三倍镜), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.四倍镜), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.六倍镜), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.八倍镜), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.侧面镜), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.战术瞄准镜), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.子弹袋), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.箭袋), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.激光瞄准镜), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.轻型握把), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.半载握把), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.UZI枪托), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.狙击枪托), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.步枪枪托), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.狙击补偿器), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.狙击枪消焰器), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.狙击枪消音器), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.步枪消音器), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.步枪补偿器), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.步枪消焰器), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.冲锋枪消音器), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.冲锋枪消焰器), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.拇指握把), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.垂直握把), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.直角握把), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.撞火枪托), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.霰弹快速), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.鸭嘴枪口), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.霰弹收束), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.狙击枪快扩), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.狙击枪扩容), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.狙击枪快速), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.步枪快扩), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.步枪扩容), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.步枪快速), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.冲锋枪快扩), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.冲锋枪扩容), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.冲锋枪快速), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.手枪快扩), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.手枪快速), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.手枪扩容), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.绘制武器箱), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.绘制药箱), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.绘制宝箱), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.军事宝箱), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&按钮.海盗福利箱), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&自瞄.初始化), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&自瞄.掉血自瞄), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&自瞄.狙击自瞄), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&自瞄.喷子自瞄), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&自瞄.动态自瞄), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&自瞄.隐藏自瞄圈), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&自瞄.随机触摸点), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&自瞄.准星射线), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&自瞄.倒地不瞄), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&自瞄.人机不瞄), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&自瞄.自瞄条件), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&自瞄.瞄准优先), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&自瞄.瞄准部位), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&自瞄.掉血自瞄数率), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&自瞄.喷子自瞄条件), sizeof(bool), 1, numSave);
  fread(static_cast<void*>(&自瞄.充电口方向), sizeof(bool), 1, numSave);
  fclose(numSave);
  inputFile.close();
}

void 绘制::OffScreen(ImDrawList *ImDraw, D4DVector Obj, float camear, ImU32 color, float Radius, float 距离)//背敌
{
    ImRect screen_rect = {0.0f, 0.0f, 真实PX, 真实PY};
    if (Obj.Z > 0 && screen_rect.Contains({Obj.X, Obj.Y}))
        return;

    auto screen_center = screen_rect.GetCenter();

    // 适当增大Radius，这里改为原来的1.5倍
    Radius *= 1.5f;

    auto angle = atan2(screen_center.y - Obj.Y, screen_center.x - Obj.X);
    angle += camear > 0? M_PI : 0.0f;
    D2DVector arrow_center {
        screen_center.x + Radius * cosf(angle),
        screen_center.y + Radius * sinf(angle)
    };

    std::array<ImVec2, 4>points {
        // 调整points数组中各点坐标，大致变为原来的1.5倍左右
        ImVec2(-33.0f, -12.9f),
        ImVec2(0.0f, 0.0f),
        ImVec2(-33.0f, 12.9f),
        ImVec2(-27.0f, 0.0f)
    };
    D2DVector tpoint;
    for (auto& point : points)
    {
        // 调整坐标变换公式中的缩放系数，适当增大
        auto x = point.x * 1.7325f;  
        auto y = point.y * 1.7325f;  
        point.x = arrow_center.X + x * cosf(angle) - y * sinf(angle);
        point.y = arrow_center.Y + x * sinf(angle) + y * cosf(angle);
        tpoint.X = point.x;
        tpoint.Y = point.y;
    }

    float alpha = 1.0f;
    if (camear > 0)
    {
        constexpr float nearThreshold = 200 * 200;
        ImVec2 screen_outer_diff = {
            Obj.X < 0? abs(Obj.X) : (Obj.X > screen_rect.Max.x? Obj.X - screen_rect.Max.x : 0.0f),
            Obj.Y < 0? abs(Obj.Y) : (Obj.Y > screen_rect.Max.y? Obj.Y - screen_rect.Max.y : 0.0f),
        };
        float distance = static_cast<float>(pow(screen_outer_diff.x, 2) + pow(screen_outer_diff.y, 2));
        alpha = camear < 0? 1.0f : (distance / nearThreshold);
    }
    ImColor arrowColor = color;
    arrowColor.Value.w = (alpha < 1.0f)? alpha : 1.0f;

    ImDraw->AddTriangleFilled(points[0], points[1], points[3], arrowColor);
    ImDraw->AddTriangleFilled(points[2],  points[1], points[3], arrowColor);
    ImDraw->AddQuad(points[0], points[1], points[2], points[3], ImColor(0.0f, 0.0f, 0.0f, alpha), 1.335f);

    // 对于被注释掉的圆形部分，如果之后启用要绘制更大圆形，也可修改radius参数
    // 比如这里假设要绘制圆形，将radius增大为原来的1.5倍
    float radius = 45.0f;  
    ImColor textColor = (arrowColor.Value.x == 0.0f)? ImColor(0.0f, 1.0f, 0.0f, alpha) : ImColor(1.0f, 0.0f, 0.0f, alpha);
    //ImDraw->AddCircle({ tpoint.X, tpoint.Y }, radius, textColor, 12, 2.0f);

    string tmp = to_string((int)距离) + "M";
    auto textSize = ImGui::CalcTextSize(tmp.c_str(), 0, 38);
    ImDraw->AddText(NULL, 38, {tpoint.X - (textSize.x / 2), tpoint.Y}, ImColor(1.0f, 1.0f, 1.0f, alpha), tmp.c_str());
}

void 绘制::初始化绘制(string 包名,int 真实X,int 真实Y){
  int pid1 = 读写.getPID(包名.c_str());
  this->pid = pid1;
  读写.初始化读写(pid1);
  绘图.初始化绘图(真实X,真实Y);
  this->真实PX = 真实X;
  this->真实PY = 真实Y;
  骨骼 = new class 骨骼(&读写);
  if(真实Y<真实X){
    this->PX = 真实X/2;
    this->PY = 真实Y/2;
  }else{
    this->PX = 真实Y/2;
    this->PY = 真实X/2;
  }
  读写.init_key("bawanglong");
  地址.libue4 = 读写.get_module_base((char*)"libUE4.so");
//  printf(" 模块地址：0x%lx\n",地址.libue4);
  //地址.libue4 = 读写.get_module_base(pid1,(char*)"libUE4.so");
}

int 绘制::findminat()
{
  float DistanceMin = 450.0f;
  float min = 自瞄.自瞄范围;
  int minAt = 999;
  for (int i = 0; i < 自瞄.瞄准总数量; i++)
  {
    switch ((int)自瞄.瞄准优先) {
      case 0:
      if (自瞄函数[i].准心距离 < min && 自瞄函数[i].准心距离 != 0)
      {
        min = 自瞄函数[i].准心距离;
        minAt = i;
      }
      break;
      case 1:
      if (自瞄函数[i].准心距离 < 自瞄.自瞄范围) {
        if (自瞄函数[i].距离 < DistanceMin)
        {
          DistanceMin = 自瞄函数[i].距离;
          minAt = i;
        }
      }
      break;
    }
  }
  if (minAt == 999)
  {
    自瞄.瞄准目标 = -1;
    return -1;
  }
  自瞄.瞄准目标 = minAt;
  return minAt;
}

void 绘制::GetTouch() {
    std::thread* 触摸位置线程 = new std::thread([&] {
    for(;;)
    {
      usleep(1000000 / 120);
      ImGuiIO& iooi = ImGui::GetIO();
      if (自瞄.触摸位置 && iooi.MouseDown[0] && iooi.MousePos.x <= 自瞄.触摸范围X + 自瞄.触摸范围 && iooi.MousePos.y <= displayInfo.height - 自瞄.触摸范围Y + 自瞄.触摸范围 && iooi.MousePos.x >= 自瞄.触摸范围X - 自瞄.触摸范围 && iooi.MousePos.y >= displayInfo.height - 自瞄.触摸范围Y - 自瞄.触摸范围)
      {
        usleep(30000);
        if (自瞄.触摸位置 && iooi.MouseDown[0] && iooi.MousePos.x <= 自瞄.触摸范围X + 自瞄.触摸范围 && iooi.MousePos.y <= displayInfo.height - 自瞄.触摸范围Y + 自瞄.触摸范围 && iooi.MousePos.x >= 自瞄.触摸范围X - 自瞄.触摸范围 && iooi.MousePos.y >= displayInfo.height - 自瞄.触摸范围Y - 自瞄.触摸范围)
        {
          while (自瞄.触摸位置 && iooi.MouseDown[0] && iooi.MousePos.x <= 自瞄.触摸范围X + 自瞄.触摸范围 && iooi.MousePos.y <= displayInfo.height - 自瞄.触摸范围Y + 自瞄.触摸范围 && iooi.MousePos.x >= 自瞄.触摸范围X - 自瞄.触摸范围 && iooi.MousePos.y >= displayInfo.height - 自瞄.触摸范围Y - 自瞄.触摸范围)
          {
            自瞄.触摸范围X = iooi.MousePos.x;
            自瞄.触摸范围Y = displayInfo.height - iooi.MousePos.y;
            usleep(500);
          }
        }
      }
    } });
    触摸位置线程->detach();
}
bool 绘制::自瞄触发(float 距离) {
    if (自瞄.喷子自瞄) {
        if (自身数据.手持 == 104003 || 自身数据.手持 == 104005 || 自身数据.手持 == 104100 || 自身数据.手持 == 104004) {
            if (距离 < 自瞄.喷子距离限制) {
                if (自瞄.喷子自瞄条件 == 0 || (自瞄.喷子自瞄条件 == 1 && 自身数据.开镜 != 0)) {
                    return true;
                }
            }
        }
    }
    if (自瞄函数[自瞄.瞄准目标].距离 > 自瞄.自瞄距离限制) {
        return false;
    }
    if (自瞄函数[自瞄.瞄准目标].距离 > 自瞄.腰射距离限制 && 自身数据.开火 != 0 && 自身数据.Fov > 75) {
        return false;
    }
    if (自瞄.狙击自瞄) {
        if (自身数据.手持 == 103011 || 自身数据.手持 == 103001 || 自身数据.手持 == 103003 || 自身数据.手持 == 103015 || 自身数据.手持 == 103012 || 自身数据.手持 == 103002) {
            if (自身数据.开镜 != 0) {
                return true;
            }
        }
    }
    switch (static_cast<int>(自瞄.自瞄条件)) {
        case 0:
            if (自身数据.开火 != 1) {
                return false;
            }
            break;
        case 1:
            if (自身数据.开镜 != 1) {
                return false;
            }
            break;
        case 2:
            if (自身数据.开火 == 0 && 自身数据.开镜 == 0) {
                return false;
            }
            break;
        default:
            return false;
    }
    return true;
}
void 绘制::驱动自瞄主线程() {
    D3DVector aimatPlace;
    D2DVector PointingAngle = {479.5f, 479.5f};
    自瞄.动态范围 = 自瞄.自瞄范围;
    findminat();
    // 注释掉以下代码，因为不确定其用途
    // 读写.WriteFloat(自身数据.驱动自瞄地址, -70);
    // 读写.WriteFloat(自身数据.驱动自瞄地址 + 0x4, 75);
    // 读写.WriteFloat(自身数据.驱动自瞄地址 + 0x8, 0);
    // 读写.WriteFloat(自身数据.驱动自瞄地址 + 0xc, 359.998993);
    if (自瞄.瞄准目标 == -1) {
        return;
    }
    // 获取瞄准位置
    switch (自瞄.瞄准部位) {
        case 0:
            aimatPlace = 骨骼->getBoneXYZ(自瞄函数[自瞄.瞄准目标].Human, 自瞄函数[自瞄.瞄准目标].Bone, 5);
            break;
        case 1:
            aimatPlace = 骨骼->getBoneXYZ(自瞄函数[自瞄.瞄准目标].Human, 自瞄函数[自瞄.瞄准目标].Bone, 4.5);
            break;
        case 2:
            aimatPlace = 骨骼->getBoneXYZ(自瞄函数[自瞄.瞄准目标].Human, 自瞄函数[自瞄.瞄准目标].Bone, 4);
            break;
        case 3:
            aimatPlace = 骨骼->getBoneXYZ(自瞄函数[自瞄.瞄准目标].Human, 自瞄函数[自瞄.瞄准目标].Bone, 1);
            break;
        default:
            aimatPlace = 骨骼->getBoneXYZ(自瞄函数[自瞄.瞄准目标].Human, 自瞄函数[自瞄.瞄准目标].Bone, 0);
            break;
    }
    // 计算瞄准角度
    PointingAngle = 骨骼->getPointingAngle(地址.自身地址, aimatPlace.X, aimatPlace.Y, aimatPlace.Z,
                                           自身数据.坐标.X, 自身数据.坐标.Y, 自身数据.坐标.Z,
                                          自瞄函数[自瞄.瞄准目标].人物向量, 自瞄函数[自瞄.瞄准目标].距离, 自瞄.预判力度);
    // 计算飞行时间
    float FlyTime = 自瞄函数[自瞄.瞄准目标].距离 / (自身数据.子弹速度 * 0.01f) * 自瞄.预判力度;
    // 计算目标位置
    D3DVector obj;
    obj.X = 自瞄函数[自瞄.瞄准目标].瞄准坐标.X + (自瞄函数[自瞄.瞄准目标].人物向量.X * FlyTime);
    obj.Y = 自瞄函数[自瞄.瞄准目标].瞄准坐标.Y + (自瞄函数[自瞄.瞄准目标].人物向量.Y * FlyTime);
    obj.Z = 自瞄函数[自瞄.瞄准目标].瞄准坐标.Z + (自瞄函数[自瞄.瞄准目标].人物向量.Z * FlyTime * FlyTime);
    // 计算屏幕坐标
    float cameras = 自身数据.矩阵[3] * obj.X + 自身数据.矩阵[7] * obj.Y + 自身数据.矩阵[11] * obj.Z + 自身数据.矩阵[15];
    D2DVector vpvp = 计算.计算屏幕坐标2(自身数据.矩阵, obj, PX, PY);
    // 计算瞄准距离
    float Aimdistance = std::hypot(PX - vpvp.X, PY - vpvp.Y);
    // 动态调整自瞄范围
    if (自瞄.动态自瞄 && (自身数据.开火 == 1 || 自身数据.开镜 != 0)) {
        自瞄.动态范围 = Aimdistance;
    } else {
        自瞄.动态范围 = 自瞄.自瞄范围;
    }
    // 计算压枪力度
    float 压枪力度 = 自瞄.压枪力度;
    float resistance = 0.0f;
    if (自身数据.开火 == 1) {
        if (自身数据.手持 == 101001 || 自身数据.手持 == 101005) {
            PointingAngle.X -= 0.15f;
        }
        if (自身数据.人物高度 == 120.0f) {
            压枪力度 -= 驱动_Recoil(自身数据.手持) * 自瞄.趴下位置调节;
            if (自身数据.手持 == 101008 || 自身数据.手持 == 101001 || 自身数据.手持 == 101005 || 自身数据.手持 == 105001) {
                PointingAngle.X += 0.15f;
            }
            if (自身数据.手持 == 101008 || 自身数据.手持 == 101005) {
                PointingAngle.X += 0.17f;
            }
        }
        resistance = 自身数据.后坐力数据 * (压枪力度 * 驱动_GetWeaponId(自身数据.手持));
    }
    // 其他逻辑...
}
/*
void 绘制::掩体线程() {
    std::thread*掩体线程 = new std::thread([&]{
        if (漏打开关 && 自瞄.初始化 && 自瞄.瞄准目标 != -1 && 自瞄函数[自瞄.瞄准目标].准心距离 <= 自瞄.自瞄范围) {
            for (int i = 0; i < 14; i++) {
                Shelter[i] = LineOfSightTo(自瞄函数[自瞄.瞄准目标].骨骼坐标[i]);
                if (Shelter[i]) {
                  break;
                }
                usleep(500);
            }
        }        
    });
    掩体线程->detach();
}
*/
void 绘制::自瞄主线程() {
  std::thread*自瞄线程 = new std::thread([&]{
    bool isDown = false;
    double tx = 自瞄.触摸范围Y, ty = 自瞄.触摸范围X;
    double ScreenX = displayInfo.width, ScreenY = displayInfo.height;
    float halfSize = 自瞄.触摸范围 / 2;
    double RandomnumberX = 自瞄.触摸范围Y,RandomnumberY = 自瞄.触摸范围X;
    
    if (自瞄.随机触摸点) {
      RandomnumberY = 自瞄.触摸范围X - halfSize + (rand() % (int)自瞄.触摸范围);
      RandomnumberX = 自瞄.触摸范围Y - halfSize + (rand() % (int)自瞄.触摸范围);
      tx = RandomnumberX, ty = RandomnumberY;    
    }
    
    double ScrXH = ScreenX / 2.0f;
    double ScrYH = ScreenY / 2.0f;
    static float TargetX = 0;
    static float TargetY = 0;
    D3DVector obj;
    float NowCoor[3];
    float zm_x,zm_y;
    
    int 目标血量 = 100;
    string 目标名字;
    bool 自瞄测试 = false;
    int 数率 = 0;
    
    timer AimFPS;
    AimFPS.SetFps(120);
    AimFPS.AotuFPS_init();
    AimFPS.setAffinity();
    
    while (1)
    {
    if (!自瞄.随机触摸点) {
        RandomnumberX = 自瞄.触摸范围Y,RandomnumberY = 自瞄.触摸范围X;
      }
      if (!自瞄.初始化)
      {
        if (isDown == true)
        {
        if (自瞄.随机触摸点) {
            RandomnumberY = 自瞄.触摸范围X - halfSize + (rand() % (int)自瞄.触摸范围);
            RandomnumberX = 自瞄.触摸范围Y - halfSize + (rand() % (int)自瞄.触摸范围);
            tx = RandomnumberX, ty = RandomnumberY;
          }
          // 恢复变量
          Touch_Up();
          // 抬起
          isDown = false;
        }
        
        usleep(自瞄.自瞄速度 * 1000);
        continue;
      }
      findminat();
      if (自瞄.瞄准目标 == -1)
      {
        if (isDown == true)
        {
          tx = 自瞄.触摸范围Y, ty = 自瞄.触摸范围X;
          if (自瞄.随机触摸点) {
            RandomnumberY = 自瞄.触摸范围X - halfSize + (rand() % (int)自瞄.触摸范围);
            RandomnumberX = 自瞄.触摸范围Y - halfSize + (rand() % (int)自瞄.触摸范围);
            tx = RandomnumberX, ty = RandomnumberY;
          }
          // 恢复变量
          Touch_Up();
          // 抬起
          isDown = false;
        }
        usleep(自瞄.自瞄速度 * 1000);
        continue;
      }
      
      
      float ToReticleDistance = 自瞄函数[自瞄.瞄准目标].准心距离;
      float BulletFlightTime = 自瞄函数[自瞄.瞄准目标].距离 / 自身数据.子弹速度;
      float FlyTime;
      if (自瞄函数[自瞄.瞄准目标].距离 >= 40) {
        FlyTime = 自瞄函数[自瞄.瞄准目标].距离 / (自身数据.子弹速度 * 0.01f) * 自瞄.预判力度;
      }else {
        FlyTime = 自瞄函数[自瞄.瞄准目标].距离 / (自身数据.子弹速度 * 0.0055f) * 自瞄.预判力度;
      }
      float DropM = 540.0f * BulletFlightTime * BulletFlightTime;
      float 压枪力度 = 自瞄.压枪力度;
      if (自身数据.人物高度 == 120.0f) {
        压枪力度 = 自瞄.压枪力度-(Recoil(自身数据.手持)*自瞄.趴下位置调节);
      }
      
      NowCoor[0] = 自瞄函数[自瞄.瞄准目标].瞄准坐标.X;
      NowCoor[1] = 自瞄函数[自瞄.瞄准目标].瞄准坐标.Y;
      NowCoor[2] = 自瞄函数[自瞄.瞄准目标].瞄准坐标.Z;
      obj.X = NowCoor[0] + (自瞄函数[自瞄.瞄准目标].人物向量.X * FlyTime);
      obj.Y = NowCoor[1] + (自瞄函数[自瞄.瞄准目标].人物向量.Y * FlyTime);
      obj.Z = NowCoor[2] + (自瞄函数[自瞄.瞄准目标].人物向量.Z * FlyTime) + DropM;
      if (自身数据.开火 == 1) {
        obj.Z -= 自瞄函数[自瞄.瞄准目标].距离 * 压枪力度 * GetWeaponId(自身数据.手持);
      }   
      D2DVector vpvp = 计算.计算屏幕坐标2(自身数据.矩阵, obj, PX, PY);
            
      float AimDs = sqrt(pow(PX - vpvp.X, 2) + pow(PY - vpvp.Y, 2));
      
      if(自瞄.动态自瞄 && (自身数据.开火==1 || 自身数据.开镜 == 1))
      {
        自瞄.动态范围 = AimDs;
      }else{
        自瞄.动态范围 = 自瞄.自瞄范围;
      }      
      zm_y = vpvp.X;
      zm_x = ScreenX - vpvp.Y;
      if (zm_x <= 0 || zm_x >= ScreenX || zm_y <= 0 || zm_y >= ScreenY)
      {
        if (isDown == true)
        {
          tx = 自瞄.触摸范围Y, ty = 自瞄.触摸范围X;
          if (自瞄.随机触摸点) {
            RandomnumberY = 自瞄.触摸范围X - halfSize + (rand() % (int)自瞄.触摸范围);
            RandomnumberX = 自瞄.触摸范围Y - halfSize + (rand() % (int)自瞄.触摸范围);
            tx = RandomnumberX, ty = RandomnumberY;
          }
          // 恢复变量
          Touch_Up();
          // 抬起
          isDown = false;
        }
        usleep(自瞄.自瞄速度 * 1000);
        continue;
      }
      if (ToReticleDistance <= 自瞄.自瞄范围)
      {
        if (!自瞄触发(自瞄函数[自瞄.瞄准目标].距离))
        {
          if (isDown == true)
          {
            tx = 自瞄.触摸范围Y, ty = 自瞄.触摸范围X;
            if (自瞄.随机触摸点) {
              RandomnumberY = 自瞄.触摸范围X - halfSize + (rand() % (int)自瞄.触摸范围);
              RandomnumberX = 自瞄.触摸范围Y - halfSize + (rand() % (int)自瞄.触摸范围);
              tx = RandomnumberX, ty = RandomnumberY;
            }
            // 恢复变量
            Touch_Up();
            isDown = false;
          }
          usleep(自瞄.自瞄速度 * 1000);
          continue;
        }
        
         if (自瞄.框内自瞄) {
        if ((自瞄函数[自瞄.瞄准目标].人物向量.X == 0 and AimDs > 35) or (自瞄函数[自瞄.瞄准目标].人物向量.X != 0 and AimDs > 65))
        {
          if (isDown == true)
          {
            tx = 自瞄.触摸范围Y, ty = 自瞄.触摸范围X;
            if (自瞄.随机触摸点) {
              RandomnumberY = 自瞄.触摸范围X - halfSize + (rand() % (int)自瞄.触摸范围);
              RandomnumberX = 自瞄.触摸范围Y - halfSize + (rand() % (int)自瞄.触摸范围);
              tx = RandomnumberX, ty = RandomnumberY;
            }
            // 恢复变量
            Touch_Up();
            isDown = false;
          }
          usleep(自瞄.自瞄速度 * 1000);
          continue;
        }
        }
        
          if (自瞄.掉血自瞄) {
          if (数率 > 0) {
            数率++;
            if (数率 == (int)自瞄.掉血自瞄数率) {
              数率 = 0;
            }
          }else {
            if (自瞄函数[自瞄.瞄准目标].名字 == 目标名字) {
              if (自瞄函数[自瞄.瞄准目标].血量 >= 目标血量) {
                目标血量 = 自瞄函数[自瞄.瞄准目标].血量;
                continue;
              }else {
                数率++;
                目标血量 = 自瞄函数[自瞄.瞄准目标].血量;
              }
            }else {
              目标名字 = 自瞄函数[自瞄.瞄准目标].名字;
              目标血量 = 自瞄函数[自瞄.瞄准目标].血量;
              continue;
            }
          }
        }
        
        if (isDown == false)
        {
          if (自瞄.充电口方向 == 0)
            Touch_Down((int)tx, (int)ty);
          else
            Touch_Down(displayInfo.height - (int)tx, displayInfo.width - (int)ty);
          isDown = true;
        }
        
        float Acc = getScopeAcc((int)(90 / 自身数据.Fov));        
        if (zm_x > ScrXH) {
          TargetX = -(ScrXH - zm_x) / 自瞄.自瞄速度 * Acc;
          if (TargetX + ScrXH > ScrXH * 2) {
            TargetX = 0;
          }
        }
        else if (zm_x < ScrXH) {
          TargetX = (zm_x - ScrXH) / 自瞄.自瞄速度 * Acc;
          if (TargetX + ScrXH < 0) {
            TargetX = 0;
          }
        }
        
        if (zm_y > ScrYH) {
          TargetY = -(ScrYH - zm_y) / 自瞄.自瞄速度 * Acc;
          if (TargetY + ScrYH > ScrYH * 2) {
            TargetY = 0;
          }
        }
        else if (zm_y < ScrYH) {
          TargetY = (zm_y - ScrYH) / 自瞄.自瞄速度 * Acc;
          if (TargetY + ScrYH < 0) {
            TargetY = 0;
          }
        }
        if (TargetY >= 35 || TargetX >= 35 || TargetY <= -35 || TargetX <= -35)
        {
          if (isDown == true)
          {
            tx = 自瞄.触摸范围Y, ty = 自瞄.触摸范围X;
            if (自瞄.随机触摸点) {
              RandomnumberY = 自瞄.触摸范围X - halfSize + (rand() % (int)自瞄.触摸范围);
              RandomnumberX = 自瞄.触摸范围Y - halfSize + (rand() % (int)自瞄.触摸范围);
              tx = RandomnumberX, ty = RandomnumberY;
            }
            // 恢复变量
            Touch_Up();
            isDown = false;
          }
          usleep(自瞄.自瞄速度 * 1000);
          continue;
        }
        
        tx += TargetX;
        ty += TargetY;
        if (tx >= RandomnumberX + 自瞄.触摸范围 || tx <= RandomnumberX - 自瞄.触摸范围
        || ty >= RandomnumberY + 自瞄.触摸范围 || ty <= RandomnumberY - 自瞄.触摸范围)
        {
          tx = 自瞄.触摸范围Y, ty = 自瞄.触摸范围X;
          if (自瞄.随机触摸点) {
            RandomnumberY = 自瞄.触摸范围X - halfSize + (rand() % (int)自瞄.触摸范围);
            RandomnumberX = 自瞄.触摸范围Y - halfSize + (rand() % (int)自瞄.触摸范围);
            tx = RandomnumberX, ty = RandomnumberY;
          }
          // 恢复变量
          Touch_Up();
          // 抬起
          
          if (自瞄.充电口方向 == 0)
            Touch_Down((int)tx, (int)ty);
          else
            Touch_Down(displayInfo.height - (int)tx, displayInfo.width - (int)ty);         
          
          isDown = true;
        }
        if (自瞄.充电口方向 == 0)
          Touch_Move((int)tx, (int)ty);
        else
          Touch_Move(displayInfo.height - (int)tx, displayInfo.width - (int)ty);
        isDown = true;
      }
      else
      {
        if (isDown == true)
         {
          tx = 自瞄.触摸范围Y, ty = 自瞄.触摸范围X;
          if (自瞄.随机触摸点) {
            RandomnumberY = 自瞄.触摸范围X - halfSize + (rand() % (int)自瞄.触摸范围);
            RandomnumberX = 自瞄.触摸范围Y - halfSize + (rand() % (int)自瞄.触摸范围);
            tx = RandomnumberX, ty = RandomnumberY;
          }
          // 恢复变量
          Touch_Up();
          // 抬起
          isDown = false;
        }
      }
      usleep(自瞄.自瞄速度 * 1000);
      AimFPS.SetFps(按钮.当前帧率);
      AimFPS.AotuFPS();
    }
  });
  自瞄线程->detach();
}

void 绘制::更新地址数据() {
  地址.世界地址 = 读写.getPtr64(读写.getPtr64(地址.libue4 + 0x11259798) + 0x90);//Gworld
    地址.自身地址 = 读写.getPtr64(读写.getPtr64(读写.getPtr64(读写.getPtr64(读写.getPtr64(地址.libue4 + 0x11259798) + 0x98) + 0x88) + 0x30) + 0x3150);
    地址.矩阵地址 = 读写.getPtr64(读写.getPtr64(地址.libue4 + 0x1122C960) + 0x20) + 0x270;//Matrix
    地址.矩阵地址_Tol = 读写.getPtr64(读写.getPtr64(地址.libue4 + 0x112313B0) + 0x98) + 0x750;
    地址.数组地址 = 读写.getPtr64(地址.世界地址 + 0xA0);
 //   世界数量 = 读写.getDword(地址.世界地址 + 0xA8);
    地址.类地址 = 读写.getPtr64(地址.libue4 + 0x10BE9988);//Gname
    读写.readv(地址.矩阵地址_Tol - 0x10, &自身数据.坐标, sizeof(自身数据.坐标));  // 更新坐标
    读写.readv(地址.矩阵地址, &自身数据.矩阵, sizeof(自身数据.矩阵));             // 更新矩阵信息
    自身数据.自身队伍 = 读写.getDword(地址.自身地址 + 0xA98);// 队伍编号
    自身数据.自身状态 = 读写.getDword(读写.getPtr64(地址.自身地址 + 0x1478));//动作ID
    自身数据.开镜 = 读写.getDword(地址.自身地址 + 0x15a8);
    自身数据.开火 = 读写.getDword(地址.自身地址 + 0x2150);
    自身数据.手持 = 读写.getDword(读写.getPtr64(读写.getPtr64(地址.自身地址 + 0x2e70) + 0x658) + 0xb90);//手持武器id
    自身数据.Fov = 读写.getFloat(读写.getPtr64(读写.getPtr64(地址.自身地址 + 0x5138) + 0x5E8) + 0x610);
    自身数据.子弹速度 = 读写.getFloat(读写.getPtr64(读写.getPtr64(地址.自身地址 + 0xf80) + 0xa60) + 0x13a4);
    自身数据.驱动自瞄地址 = 读写.getPtr64(读写.getPtr64(地址.自身地址 + 0x4f58) + 0x5f8) + 0x1fb8 + 0x10;
    自身数据.后坐力数据 = 读写.getFloat(读写.getPtr64(读写.getPtr64(地址.自身地址 + 0xf80) + 0xa60) + 0x1948);
  //自身数据.头 = 读写.getFloat(读写.getPtr64(读写.getPtr64(读写.getPtr64(读写.getPtr64(读写.getPtr64(地址.自身地址+0x408)+0x50)+0x210)+0x5e8)+0x18)+0x58);
  //自身数据.甲 = 读写.getFloat(读写.getPtr64(读写.getPtr64(读写.getPtr64(读写.getPtr64(读写.getPtr64(地址.自身地址+0x408)+0x50)+0x210)+0x5e8)+0x18)-0x58);  
  自身数据.准星Y = 读写.getFloat(读写.getPtr64(地址.自身地址 + 0x5138) + 0x58c) - 90;
  自身数据.人物高度 = 读写.getFloat(地址.自身地址 + 0xed0);
  
  //读写.readv(读写.getPtr64(地址.自身地址 + 0x46d0)+ 0x574,&自身数据.准星,sizeof(自身数据.准星));
}


void 绘制::更新对象数据()
{
  if (自瞄.触摸位置) 绘图.绘制自瞄触摸范围(自瞄.触摸范围,自瞄.触摸范围X,自瞄.触摸范围Y);
  if(!自瞄.动态自瞄)
  {
    自瞄.动态范围 = 自瞄.自瞄范围;
  }
  if (自瞄.初始化 &&!自瞄.隐藏自瞄圈) {
    ImDrawList* drawList = ImGui::GetForegroundDrawList();
    drawList->AddCircle(
        ImVec2(PX, PY),  // 圆心坐标
        自瞄.动态范围,   // 圆的半径
        ImColor(255, 0, 0, 255),  // 颜色（不透明红色）
        0,  // 起始角度（一般从0度开始绘制等情况用0，可按需改）
        2.0f  // 绘制的角度范围（弧度制，这里示例，可根据实际调整）
    );
}
  if (按钮.雷达) {
    绘图.RenderRadarScan(ImGui::GetForegroundDrawList(), ImVec2(按钮.雷达X,按钮.雷达Y), 150.0f, 100, 按钮.rotationAngle, 150.0f);
  }
  int 绘制人机=0,绘制真人=0;被瞄准对象数量=0;自瞄.瞄准对象数量 = 0;
  for(int a = 0;a<读写.getDword(地址.世界地址+0xA8);a++){
    对象地址.敌人地址 = 读写.getPtr64(地址.数组地址+a*8);
    读写.readv(读写.getPtr64(对象地址.敌人地址+0x278)+0x1F0,&对象信息.敌人信息.坐标,sizeof(对象信息.敌人信息.坐标));//更新坐标
    
    对象信息.敌人信息.距离 = 计算.计算距离(自身数据.坐标,对象信息.敌人信息.坐标);//距离
    
    float camear_r = 自身数据.矩阵[3] * 对象信息.敌人信息.坐标.X + 自身数据.矩阵[7] * 对象信息.敌人信息.坐标.Y + 自身数据.矩阵[11] * 对象信息.敌人信息.坐标.Z + 自身数据.矩阵[15];
    float r_x = PX + (自身数据.矩阵[0] * 对象信息.敌人信息.坐标.X + 自身数据.矩阵[4] * 对象信息.敌人信息.坐标.Y + 自身数据.矩阵[8] * 对象信息.敌人信息.坐标.Z +自身数据.矩阵[12]) / camear_r * PX;
    float r_y = PY - (自身数据.矩阵[1] * 对象信息.敌人信息.坐标.X + 自身数据.矩阵[5] * 对象信息.敌人信息.坐标.Y + 自身数据.矩阵[9] * (对象信息.敌人信息.坐标.Z - 5) +自身数据.矩阵[13]) / camear_r * PY;
    float r_z = PY - (自身数据.矩阵[1] * 对象信息.敌人信息.坐标.X + 自身数据.矩阵[5] * 对象信息.敌人信息.坐标.Y + 自身数据.矩阵[9] * (对象信息.敌人信息.坐标.Z + 205) +自身数据.矩阵[13]) / camear_r * PY;
    D4DVector t_屏幕坐标 = {r_x-(r_y-r_z)/4,r_y,(r_y-r_z)/2,r_y-r_z};
    
    char 计算地址[256] = "我是帅哥";
   sprintf(计算地址, "%lx",对象地址.敌人地址);
    
    if (按钮.手雷预警) {       
      int 手雷ID = 读写.getDword(对象地址.敌人地址 + 0x71C);  
      const char* 投掷物信息 = Getagrenade(手雷ID);
      if (手雷ID == 602004 or 手雷ID == 9825004) {
        if (!计时器.hasTimer(计算地址)) {
          手雷类.add(计算地址,对象信息.敌人信息.坐标.X,对象信息.敌人信息.坐标.Y);
        }else {
          手雷类.remove(计算地址);
        }
      }
      if (投掷物信息 != nullptr) {
        std::string name = 投掷物信息;
        if (t_屏幕坐标.W > 0) {
          float 计算_max = 7-(计时器.getTimerSeconds(计算地址)/7*(60/ImGui::GetIO().Framerate*0.115));
          if (计算_max >= 0) {
            name += "[" + std::to_string((int)对象信息.敌人信息.距离) + "米]";
            auto textSize = ImGui::CalcTextSize(name.c_str(), 0, 35);
            ImGui::GetForegroundDrawList()->AddText(NULL, 35, {r_x - (textSize.x / 2), r_y + 30}, ImColor(255, 0, 0, 255), name.c_str());
            if (手雷ID == 602004 or 手雷ID == 9825004) {
              float 计时 = 计算_max/7*100;
              //printf("%d\n",std::stoi(计算));
              float aa = 计时*3.6;
              ImGui::GetForegroundDrawList()->AddCircleArc({r_x, r_y},30, {0, 100*3.6}, ImColor(255, 255, 255, 100),  0, 5);
              ImGui::GetForegroundDrawList()->AddCircleArc({r_x, r_y},30, {0, aa}, ImColor(0,255,0,255),  0, 5);
              
              string 计算 = std::to_string((int)计算_max);
              textSize = ImGui::CalcTextSize(计算.c_str(), 0, 38);
              ImGui::GetForegroundDrawList()->AddText(NULL, 38, {r_x  - (textSize.x / 2), r_y - 18}, ImColor(255, 0, 0, 255), 计算.c_str());
            }
          }
          
        }      
      }
    }    
    char ClassName[64] = "";
      char 对象信息_max[200] = "";
      int ClassID = 读写.getPtr64(对象地址.敌人地址 + 24);
      long int FNameEntry = 读写.getPtr64(读写.getPtr64(地址.类地址 + (ClassID / 0x4000) * 0x8) + (ClassID % 0x4000) * 0x8);
      读写.readv(FNameEntry + 0xC, ClassName, 64);
 
  if (t_屏幕坐标.W > 0) {   
    if (按钮.车辆) {
        long long VehicleData = 读写.getPtr64(对象地址.敌人地址 + 0xA98);
        float 载具血量 = 读写.getFloat(VehicleData + 0x1EC + 0x4) / 读写.getFloat(VehicleData + 0x1EC) * 100;
        float 载具油量 = 读写.getFloat(VehicleData + 0x210 + 0x4) / 读写.getFloat(VehicleData + 0x210) * 100;
        if ((int)载具血量 != 0 && (int)载具油量 != 0) {
          std::string name = getMaterialName(ClassName);
          if (name != "Error" && 对象信息.敌人信息.距离 > 7) {
            name += " | " + std::to_string((int)对象信息.敌人信息.距离) + "M | 耐久:" + std::to_string((int)载具血量) + " | 油量:" + std::to_string((int)载具油量);
            auto textSize = ImGui::CalcTextSize(name.c_str(), 0, 25);
            ImGui::GetForegroundDrawList()->AddText(NULL, 25, {r_x - (textSize.x / 2), r_y}, ImColor(255, 255, 0, 255), name.c_str());            //车图片调用
            
          }
        }
      }      
    

        if (按钮.盒子 && (strstr(ClassName, "RollTombBox_") != 0 or strstr(ClassName, "EscapePlayerTombBox") != 0 or strstr(ClassName, "DeadInventoryBox") != 0 or strstr(ClassName, "_TrainingBoxListWrapper_C") != 0)) {
        ImGui::GetBackgroundDrawList()->AddImage(手持图片[12].textureId, ImVec2(t_屏幕坐标.X + 14 , t_屏幕坐标.Y - 40), ImVec2(t_屏幕坐标.X + 54, t_屏幕坐标.Y));
        std::string name = "盒子[";
        name += std::to_string((int)对象信息.敌人信息.距离);
        name += "M]";
        auto textSize = ImGui::CalcTextSize(name.c_str(), 0, 25);
        ImGui::GetForegroundDrawList()->AddText(NULL, 25, {t_屏幕坐标.X-(textSize.x / 2) + 50, t_屏幕坐标.Y}, ImColor(255, 255, 0, 255), name.c_str());
      }
      
      if (按钮.金仓 && strstr(ClassName, "PeopleSkill") != NULL) {
    ImGui::GetBackgroundDrawList()->AddImage(手持图片[12].textureId, ImVec2(t_屏幕坐标.X + 14 , t_屏幕坐标.Y - 40), ImVec2(t_屏幕坐标.X + 54, t_屏幕坐标.Y));
    std::string name = "金仓[";
    name += std::to_string((int)对象信息.敌人信息.距离);
    name += "M]";
    auto textSize = ImGui::CalcTextSize(name.c_str(), 0, 25);
    ImGui::GetForegroundDrawList()->AddText(NULL, 25, {t_屏幕坐标.X-(textSize.x / 2) + 50, t_屏幕坐标.Y}, ImColor(255, 255, 0, 255), name.c_str());
}

     if (按钮.军事宝箱 && strstr(ClassName, "MilitarySupplyBoxBase_Baltic_Theme_C") != NULL) {
    ImGui::GetBackgroundDrawList()->AddImage(手持图片[12].textureId, ImVec2(t_屏幕坐标.X + 14 , t_屏幕坐标.Y - 40), ImVec2(t_屏幕坐标.X + 54, t_屏幕坐标.Y));
    std::string name = "军事宝箱[";
    name += std::to_string((int)对象信息.敌人信息.距离);
    name += "M]";
    auto textSize = ImGui::CalcTextSize(name.c_str(), 0, 25);
    ImGui::GetForegroundDrawList()->AddText(NULL, 25, {t_屏幕坐标.X-(textSize.x / 2) + 50, t_屏幕坐标.Y}, ImColor(255, 255, 255, 255), name.c_str());
}

   if (按钮.海盗福利箱 && strstr(ClassName, "CG30_ActivityCommonTreasureBox_C") != NULL) {
    ImGui::GetBackgroundDrawList()->AddImage(手持图片[12].textureId, ImVec2(t_屏幕坐标.X + 14 , t_屏幕坐标.Y - 40), ImVec2(t_屏幕坐标.X + 54, t_屏幕坐标.Y));
    std::string name = "海盗福利箱[";
    name += std::to_string((int)对象信息.敌人信息.距离);
    name += "M]";
    auto textSize = ImGui::CalcTextSize(name.c_str(), 0, 25);
    ImGui::GetForegroundDrawList()->AddText(NULL, 25, {t_屏幕坐标.X-(textSize.x / 2) + 50, t_屏幕坐标.Y}, ImColor(255, 255, 255, 255), name.c_str());
}

           if (按钮.空投 && strstr(ClassName, "_AirDropBox_C") != NULL) {
    ImGui::GetBackgroundDrawList()->AddImage(手持图片[12].textureId, ImVec2(t_屏幕坐标.X + 14 , t_屏幕坐标.Y - 40), ImVec2(t_屏幕坐标.X + 54, t_屏幕坐标.Y));
    std::string name = "空投[";
    name += std::to_string((int)对象信息.敌人信息.距离);
    name += "M]";
    auto textSize = ImGui::CalcTextSize(name.c_str(), 0, 25);
    ImGui::GetForegroundDrawList()->AddText(NULL, 25, {t_屏幕坐标.X-(textSize.x / 2) + 50, t_屏幕坐标.Y}, ImColor(255, 255, 0, 255), name.c_str());
}
      

//地铁👇🏻

    
      
      if (按钮.绘制宝箱 && (strstr(ClassName, "EscapeBox_SupplyBox_") != 0 or strstr(ClassName, "EscapeBoxHight_SupplyBox_") != 0)) {
        std::string name = "宝箱 ";
        name += Level(ClassName);
        if (读写.getDword(对象地址.敌人地址 + 0x270) == 1) {
          name += " 已开启";
        }else {
          name += " 未开启";
        }
        name += "[" + std::to_string(static_cast<int>(对象信息.敌人信息.距离)) + "M]";
        auto textSize = ImGui::CalcTextSize(name.c_str(), 0, 25);
        ImGui::GetForegroundDrawList()->AddText(NULL, 25, {t_屏幕坐标.X-(textSize.x / 2) + 50, t_屏幕坐标.Y}, ImColor(255, 255, 0, 255), name.c_str());
      }if (按钮.绘制宝箱 && (strstr(ClassName, "EscapeBox_SpeEffect_C") != 0 or strstr(ClassName, "MilitarySupplyBoxBase_Baltic_Classic_C") != 0)) {
        ImGui::GetBackgroundDrawList()->AddImage(手持图片[13].textureId, ImVec2(t_屏幕坐标.X + 14 , t_屏幕坐标.Y - 40), ImVec2(t_屏幕坐标.X + 54, t_屏幕坐标.Y));
        std::string name = "超级宝箱 ";
        name += Level(ClassName);
        if (读写.getDword(对象地址.敌人地址 + 0x270) == 1) {
          name += " 已开启";
        }else {
          name += " 未开启";
        }
        name += "[" + std::to_string(static_cast<int>(对象信息.敌人信息.距离)) + "M]";
        auto textSize = ImGui::CalcTextSize(name.c_str(), 0, 25);
        ImGui::GetForegroundDrawList()->AddText(NULL, 25, {t_屏幕坐标.X-(textSize.x / 2) + 50, t_屏幕坐标.Y}, ImColor(255, 0, 0, 255), name.c_str());
      }if (按钮.绘制药箱 && (strstr(ClassName, "EscapeBox_Medical_") != 0 or strstr(ClassName, "EscapeBoxHight_Medical_") != 0)) {
        std::string name = "药箱 ";
        name += Level(ClassName);
        if (读写.getDword(对象地址.敌人地址 + 0x270) == 1) {
          name += " 已开启";
        }else {
          name += " 未开启";
        }
        name += "[" + std::to_string(static_cast<int>(对象信息.敌人信息.距离)) + "M]";
        auto textSize = ImGui::CalcTextSize(name.c_str(), 0, 25);
        ImGui::GetForegroundDrawList()->AddText(NULL, 25, {t_屏幕坐标.X-(textSize.x / 2) + 50, t_屏幕坐标.Y}, ImColor(0, 255, 0, 255), name.c_str());
      }if (按钮.绘制武器箱 && (strstr(ClassName, "EscapeBox_Weapon_") != 0 or strstr(ClassName, "EscapeBoxHight_Weapon_") != 0)) {
        std::string name = "武器箱 ";
        name += Level(ClassName);
        if (读写.getDword(对象地址.敌人地址 + 0x270) == 1) {
          name += " 已开启";
        }else {
          name += " 未开启";
        }
        name += "[" + std::to_string(static_cast<int>(对象信息.敌人信息.距离)) + "M]";
        auto textSize = ImGui::CalcTextSize(name.c_str(), 0, 25);
        ImGui::GetForegroundDrawList()->AddText(NULL, 25, {t_屏幕坐标.X-(textSize.x / 2) + 50, t_屏幕坐标.Y}, ImColor(255, 255, 0, 255), name.c_str());
      }


//地铁👆🏻

      
      if (按钮.物资总开关) {
int MaterialID = 读写.getDword(对象地址.敌人地址 + 0x66c);
std::string name = getBoxName(MaterialID);
if (name != "Error") {
    if (对象信息.敌人信息.距离 < 200) {
        name += "[";
        name += std::to_string((int)对象信息.敌人信息.距离);
        name += "米]";        
        // 计算文本大小
        auto textSize = ImGui::CalcTextSize(name.c_str(), NULL, 50);
        // 获取前景绘制列表
        ImDrawList* drawList = ImGui::GetForegroundDrawList();
        // 描边的偏移量
        float outlineThickness = 1.0f;
        // 绘制白色描边
        drawList->AddText(NULL, 55, ImVec2(r_x - (textSize.x / 2) - outlineThickness, r_y - outlineThickness), ImColor(255, 255, 255, 255), name.c_str());
        drawList->AddText(NULL, 55, ImVec2(r_x - (textSize.x / 2) + outlineThickness, r_y - outlineThickness), ImColor(255, 255, 255, 255), name.c_str());
        drawList->AddText(NULL, 55, ImVec2(r_x - (textSize.x / 2) - outlineThickness, r_y + outlineThickness), ImColor(255, 255, 255, 255), name.c_str());
        drawList->AddText(NULL, 55, ImVec2(r_x - (textSize.x / 2) + outlineThickness, r_y + outlineThickness), ImColor(255, 255, 255, 255), name.c_str());
        // 绘制主文本（紫色）
        drawList->AddText(NULL, 55, ImVec2(r_x - (textSize.x / 2), r_y), ImColor(128, 0, 128, 255), name.c_str());
    }
}
      }
    }
    
    if(strstr(ClassName, "BPPawn_Escape_Raven") != 0 or strstr(ClassName, "BPPawn_Escape_UAV_C") != 0) {
      continue;
    }
    
    if(读写.getFloat(对象地址.敌人地址+0xecc)==479.5 or strstr(ClassName, "BPPawn_Escape_") != 0){ 
      D4DVector 屏外预警坐标(r_x,r_y,r_y-r_z,(r_y-r_z)/2);
      对象信息.敌人信息.isboot = 读写.getDword(对象地址.敌人地址+0xab4);//人机
      对象信息.敌人信息.状态 = 读写.getDword(读写.getPtr64(对象地址.敌人地址+0x1478));
      对象信息.敌人信息.雷达 = 计算.rotateCoord(自身数据.准星Y, (自身数据.坐标.X - 对象信息.敌人信息.坐标.X) / 200, (自身数据.坐标.Y - 对象信息.敌人信息.坐标.Y) / 200);
            
      读写.readv(对象地址.敌人地址 +0xf74, &对象信息.敌人信息.向量, sizeof(对象信息.敌人信息.向量));//更新向量
      对象信息.敌人信息.Rotator = 读写.getFloat(对象地址.敌人地址+0x1A8);      
      对象信息.敌人信息.当前血量 = 读写.getFloat(对象地址.敌人地址+0xe70);//血量
      对象信息.敌人信息.最大血量 = 读写.getFloat(对象地址.敌人地址+0xe78);//最大血量
    //  对象信息.敌人信息.手持 = heldconversion(读写.getPtr64(对象地址.敌人地址 + 0xf18) +0xf10);
      对象信息.敌人信息.手持 = 读写.getDword(读写.getPtr64(读写.getPtr64(对象地址.敌人地址 + 0x2EB0) + 0x668) + 0xbA0);//手持
//      对象信息.敌人信息.子弹数量 = 读写.getDword(读写.getPtr64(读写.getPtr64(对象地址.敌人地址 + 0x2dc0) + 0x648) + 0x16e0);
  //    对象信息.敌人信息.子弹最大数量 = 读写.getDword(读写.getPtr64(读写.getPtr64(对象地址.敌人地址 + 0x2dc0) + 0x648) + 0x16e4); 
           对象信息.敌人信息.队伍 = 读写.getDword(对象地址.敌人地址+0xA98);
      long int MeshOffset = 读写.getPtr64(对象地址.敌人地址 + 0x5e0);//阵列偏移   
      int Bonecount = 读写.getPtr64(MeshOffset + 0x7b8 + 8);//骨骼指针    
      骨骼->更新骨骼数据(MeshOffset + 0x1e0,读写.getPtr64(MeshOffset + 0x7b8) + 0x30,对象信息.敌人信息.骨骼坐标,Bonecount,对象信息.敌人信息.队伍, ClassName);//骨骼阵列+骨骼指针
      char temp[64];
      读写.getUTF8(temp,读写.getPtr64(对象地址.敌人地址+0xa18));//玩家名字
      对象信息.敌人信息.名字 = temp;
      
      
      bool 是否掐雷 = false;
      //sprintf(计算地址, "%lx",对象地址.敌人地址);
      if (对象信息.敌人信息.手持 == 602004) {
        std::string 状态字符串 = std::to_string(对象信息.敌人信息.状态);
        if (状态字符串.length() == 5) {
          计时器.addTimer(计算地址, 0);
          是否掐雷 = true;
        }else {
          if (计时器.hasTimer(计算地址)){
            string 手雷递送 = 手雷类.calculateKey(对象信息.敌人信息.坐标.X,对象信息.敌人信息.坐标.Y);
            if (手雷递送 == "注意") {
              Antitankgrenade[计算地址] = Antitankgrenade[计算地址]+1;
              if (Antitankgrenade[计算地址] == 15) {
                计时器.removeTimer(计算地址);
                Antitankgrenade.erase(计算地址);//没用的东西赶紧滚
              }
            }else {
              计时器.renameTimer(计算地址,手雷递送);
              手雷类.remove(手雷递送);
            }
          }
          
        }
      }else {
        if (计时器.hasTimer(计算地址)){
          string 手雷递送 = 手雷类.calculateKey(对象信息.敌人信息.坐标.X,对象信息.敌人信息.坐标.Y);
          if (手雷递送 == "注意") {
            Antitankgrenade[计算地址] = Antitankgrenade[计算地址]+1;
            if (Antitankgrenade[计算地址] == 15) {
                计时器.removeTimer(计算地址);
                Antitankgrenade.erase(计算地址);//没用的东西赶紧滚
            }
          }else {
            计时器.renameTimer(计算地址,手雷递送);
            手雷类.remove(手雷递送);
          }
        }
      }
      //手雷倒计时计算
      
      if (读写.getDword(对象地址.敌人地址+0xA98)==自身数据.自身队伍) continue;
      if (对象信息.敌人信息.队伍 == dygl) continue;
      
      if (按钮.忽略人机 && 对象信息.敌人信息.isboot == 1){
      
     continue;
     
      }
      
      
      if (按钮.雷达)
      {
        if (对象信息.敌人信息.距离 <= 300)
        {
          if(对象信息.敌人信息.isboot == 1)
          {
            ImGui::GetForegroundDrawList()->AddCircleFilled({按钮.雷达X + 对象信息.敌人信息.雷达.X, 按钮.雷达Y + 对象信息.敌人信息.雷达.Y}, {4.5}, ImColor(255,255,255));
          }else{
            ImGui::GetForegroundDrawList()->AddCircleFilled({按钮.雷达X + 对象信息.敌人信息.雷达.X, 按钮.雷达Y + 对象信息.敌人信息.雷达.Y}, {4.5}, ImColor(255,0,0));
          }
        }
      }
      if(对象信息.敌人信息.状态==1048592||对象信息.敌人信息.状态==1048576)
      continue;
      if (对象信息.敌人信息.isboot==1) {绘制人机 ++;} else {绘制真人 ++;}
      //下面开始绘制
      骨骼数据 t_骨骼数据 = 计算.计算骨骼(自身数据.矩阵,对象信息.敌人信息.骨骼坐标,PX,PY);
      绘图.初始化坐标(t_屏幕坐标,t_骨骼数据);
      if(t_屏幕坐标.W>=0){
        if (自瞄.倒地不瞄 && 对象信息.敌人信息.当前血量 <= 0) {}
        else if (自瞄.人机不瞄 && 对象信息.敌人信息.isboot == 1) {}
        else {
        自瞄函数[自瞄.瞄准对象数量].距离 = 对象信息.敌人信息.距离;
        自瞄函数[自瞄.瞄准对象数量].人物向量 = 对象信息.敌人信息.向量;
        自瞄函数[自瞄.瞄准对象数量].血量 = 对象信息.敌人信息.当前血量;
        自瞄函数[自瞄.瞄准对象数量].Bone = 读写.getPtr64(MeshOffset + 0x7b8) + 0x30;
        自瞄函数[自瞄.瞄准对象数量].Human = MeshOffset + 0x1e0;
        自瞄函数[自瞄.瞄准对象数量].名字 = 对象信息.敌人信息.名字;
        if (自瞄.瞄准部位 == 0){
          自瞄函数[自瞄.瞄准对象数量].瞄准坐标 = 对象信息.敌人信息.骨骼坐标[0];
          自瞄函数[自瞄.瞄准对象数量].准心距离 = sqrt(pow(PX - t_骨骼数据.Head.X, 2) + pow(PY - t_骨骼数据.Head.Y, 2));
          自瞄函数[自瞄.瞄准对象数量].对象骨骼 = t_骨骼数据.Head;
        }else if (自瞄.瞄准部位 == 1){
          自瞄函数[自瞄.瞄准对象数量].瞄准坐标 = 对象信息.敌人信息.骨骼坐标[1];
          自瞄函数[自瞄.瞄准对象数量].准心距离 = sqrt(pow(PX - t_骨骼数据.Chest.X, 2) + pow(PY - t_骨骼数据.Chest.Y, 2));
          自瞄函数[自瞄.瞄准对象数量].对象骨骼 = t_骨骼数据.Chest;
        }else if (自瞄.瞄准部位 == 2){
          自瞄函数[自瞄.瞄准对象数量].瞄准坐标 = 对象信息.敌人信息.骨骼坐标[2];
          自瞄函数[自瞄.瞄准对象数量].准心距离 = sqrt(pow(PX - t_骨骼数据.Pelvis.X, 2) + pow(PY - t_骨骼数据.Pelvis.Y, 2));
          自瞄函数[自瞄.瞄准对象数量].对象骨骼 = t_骨骼数据.Pelvis;
        }
        自瞄.瞄准对象数量++;
        }
      }
      
      auto aimAngle = 计算.rotateCoord(对象信息.敌人信息.骨骼坐标[1],自身数据.坐标);
      auto aimMZ = FRotator(0, 对象信息.敌人信息.Rotator, 0);
      aimMZ.Clamp();
      float AimX = abs(aimAngle.X - aimMZ.Yaw);
      
      if (AimX <= 4) {
    //   被瞄信息[被瞄准对象数量].距离 = 对象信息.敌人信息.距离;
   //    被瞄信息[被瞄准对象数量].名字 = 对象信息.敌人信息.名字;
  //     被瞄信息[被瞄准对象数量].瞄准武器 = GetHolGunItem(对象信息.敌人信息.手持);
  //     被瞄准对象数量++;
      }
      
if (按钮.背敌预警) {
        if (对象信息.敌人信息.isboot == 1){
          OffScreen(ImGui::GetForegroundDrawList(), 屏外预警坐标, camear_r, ImColor(0, 255, 0, 255), 250, 对象信息.敌人信息.距离);
        }else {
          OffScreen(ImGui::GetForegroundDrawList(), 屏外预警坐标, camear_r, ImColor(255, 0, 0, 255), 250, 对象信息.敌人信息.距离);
        }
      }
      
      if(t_屏幕坐标.W>=0){
        if(按钮.方框) 绘图.绘制方框(对象信息.敌人信息.isboot);
        if(按钮.射线) 绘图.绘制射线(t_骨骼数据);
        if(按钮.名字) {
          绘图.绘制名字(对象信息.敌人信息.名字, 对象信息.敌人信息.isboot, 0, false, ClassName, 对象信息.敌人信息.队伍, Bonecount);
        }
        if(按钮.距离) 绘图.绘制距离(对象信息.敌人信息.距离, 对象信息.敌人信息.队伍);
        if(按钮.血量) 绘图.绘制血量(对象信息.敌人信息.最大血量,对象信息.敌人信息.当前血量,t_骨骼数据);
         if(按钮.骨骼) {                
          绘图.绘制骨骼(t_骨骼数据,t_屏幕坐标,LineOfSightTo1);
        }
        if(按钮.手持) 绘图.绘制手持(对象信息.敌人信息.手持, 对象信息.敌人信息.状态);
        if(自瞄.初始化 && 自瞄.准星射线 && 自瞄.瞄准目标 != -1 && 自瞄函数[自瞄.瞄准目标].准心距离 <= 自瞄.自瞄范围) {
        ImGui::GetForegroundDrawList()->AddLine(ImVec2(PX, PY), ImVec2(自瞄函数[自瞄.瞄准目标].对象骨骼.X, 自瞄函数[自瞄.瞄准目标].对象骨骼.Y), ImColor(255,255,255,255), 2.1);
        }
      }
    }
  }

/*
  if (按钮.被瞄) {
    绘图.绘制瞄准信息();
  } */
  if(按钮.人数) 绘图.绘制人数(绘制人机, 绘制真人);
  自瞄.瞄准总数量 = 自瞄.瞄准对象数量;
}

void 绘制::运行绘制(){
  更新地址数据();
  更新对象数据();
  
  if (!按钮.自瞄选项 && 自瞄.初始化) {
    驱动自瞄主线程();
  }
  计时器.updateTimers();
  计时器.checkAndRemoveTimers();
}
const char* 绘制::getMaterialName(char *name)
{
  static char dealname[32];
  memset(dealname, '\0', sizeof(dealname));
  if (strstr(name, "VH_MotorcycleCart") != 0)
  {
    strcpy(dealname, "三轮摩托车");
    按钮.VehicleID = 43;
  }
  else if (strstr(name, "VH_Scooter") != 0)
  {
    strcpy(dealname, "小绵羊车");
    按钮.VehicleID = 45;
  }
  else if (strstr(name, "VH_Motorcycle") != 0)
  {
    strcpy(dealname, "摩托车");
    按钮.VehicleID = 44;
  }
  else if (strstr(name, "VH_Tuk") != 0)
  {
    strcpy(dealname, "三轮摩托车");
    按钮.VehicleID = 48;
  }
  else if (strstr(name, "Buggy") != 0)
  {
    strcpy(dealname, "蹦蹦");
    按钮.VehicleID = 30;
  }
  else if (strstr(name, "Mirado") != 0)
  {
    strcpy(dealname, "敞篷跑车");
    按钮.VehicleID = 35;
  }
  else if (strstr(name, "CoupeRB") != 0)
  {
    strcpy(dealname, "跑车");
    按钮.VehicleID = 39;
  }
  else if (strstr(name, "Dacia") != 0)
  {
    strcpy(dealname, "轿车");
    按钮.VehicleID = 31;
  }
  else if (strstr(name, "PickUp_02_C") != 0)
  {
    strcpy(dealname, "皮卡");
    按钮.VehicleID = 33;
  }
  else if (strstr(name, "Rony") != 0)
  {
    strcpy(dealname, "皮卡");
    按钮.VehicleID = 38;
  }
  else if (strstr(name, "_StationWagon_C") != 0)
  {
    strcpy(dealname, "旅行车");
    按钮.VehicleID = 40;
  }
  else if (strstr(name, "VH_StationWagon_New_C") != 0)
  {
    strcpy(dealname, "旅行车");
    按钮.VehicleID = 0;
  }
  else if (strstr(name, "UAZ") != 0)
  {
    strcpy(dealname, "吉普");
    按钮.VehicleID = 32;
  }
  else if (strstr(name, "PG117") != 0)
  {
    strcpy(dealname, "快艇");
    按钮.VehicleID = 49;
  }
  else if (strstr(name, "AquaRail") != 0)
  {
    strcpy(dealname, "冲锋艇");
    按钮.VehicleID = 50;
  }
  else if (strstr(name, "MiniBus") != 0)
  {
    strcpy(dealname, "面包车");
    按钮.VehicleID = 37;
  }
  else if (strstr(name, "VH_BRDM") != 0)
  {
    strcpy(dealname, "两栖装甲车");
    按钮.VehicleID = 0;
  }
  else if (strstr(name, "LadaNiva") != 0)
  {
    strcpy(dealname, "雪地越野车");
    按钮.VehicleID = 36;
  }
  else if (strstr(name, "_4SportCar_C") != 0)
  {
    strcpy(dealname, "敞篷跑车");
    按钮.VehicleID = 41;
  }
  else if (strstr(name, "_Bigfoot_C") != 0)
  {
    strcpy(dealname, "大脚车");
    按钮.VehicleID = 53;
  }
  else if (strstr(name, "_Training_C") != 0)
  {
    strcpy(dealname, "自行车");
    按钮.VehicleID = 0;
  }
  else if (strstr(name, "VH_Drift_001_New_C") != 0)
  {
    strcpy(dealname, "拉力赛车");
    按钮.VehicleID = 0;
  }
  
  else if (strstr(name, "ATV1_C") != 0)
  {
    strcpy(dealname, "越野摩托车");
    按钮.VehicleID = 0;
  }
  else if (strstr(name, "_Horse") != 0)
  {
    strcpy(dealname, "宝马740Li");
    按钮.VehicleID = 52;
  }
  else if (strstr(name, "_02_C") != 0)
  {
    strcpy(dealname, "雪地摩托车");
    按钮.VehicleID = 46;
  }
  else if (strstr(name, "Snowmobile_C") != 0)
  {
    strcpy(dealname, "雪地摩托车");
    按钮.VehicleID = 47;
  }
  else if (strstr(name, "_Motorglider_C") != 0)
  {
    strcpy(dealname, "滑翔机");
    按钮.VehicleID = 51;
  }
  else if (strstr(name, "_Picobus_C") != 0)
  {
    strcpy(dealname, "小森口");
    按钮.VehicleID = 0;
  }
  else if (strstr(name, "_Blanc_C") != 0)
  {
    strcpy(dealname, "森口");
    按钮.VehicleID = 0;
  }
  else if (strstr(name, "_DumpTruck_C") != 0)
  {
    strcpy(dealname, "渣土车");
    按钮.VehicleID = 0;
  }
  else if (strstr(name, "_Excavator_C") != 0)
  {
    strcpy(dealname, "挖掘机");
    按钮.VehicleID = 0;
  }
  else if (strstr(name, "_DesertCar_C") != 0)
  {
    strcpy(dealname, "沙漠越野车");
    按钮.VehicleID = 0;
  }
  else {
    strcpy(dealname,"Error");
  }
  return dealname;
}

string 绘制::getBoxName(int id) {
  if (按钮.信号枪) {
    if (id == 106007) return "[道具]信号枪";
  }if (按钮.电竞信号枪) {
    if (id == 106017) return "[道具]电竞信号枪";
  }if (按钮.召回信号枪) {
    if (id == 106094) return "[道具]召回信号枪";
  }if (按钮.圣诞信号枪) {
    if (id == 106098) return "[道具]圣诞信号枪";
  }if (按钮.夏日信号枪) {
    if (id == 106110) return "[道具]夏日信号枪";
  }if (按钮.盔仔信号枪) {
    if (id == 106112) return "[道具]盔仔信号枪";  
  }if (按钮.自救器){
    if (id == 604014 || id == 604086) return "[救助]自救器";
  }if (按钮.医疗箱) {
    if (id == 601006) return "[药品]医疗箱";
  }if (按钮.急救包) {
    if (id == 601005) return "[药品]急救包";
  }if (按钮.绷带) {
    if (id == 601004) return "[药品]绷带";
  }if (按钮.可乐) {
    if (id == 601001) return "[药品]可乐";
  }if (按钮.肾上腺素) {
    if (id == 601002) return "[药品]肾上腺素";
  }if (按钮.止痛药) {
    if (id == 601003) return "[药品]止痛药";
  }if (按钮.一级甲) {
    if (id == 503001) return "[防具]一级防弹衣";
  }if (按钮.二级甲) {
    if (id == 503002) return "[防具]二级防弹衣";
  }if (按钮.三级甲) {
    if (id == 503003) return "[防具]三级防弹衣";
  }if (按钮.一级头) {
    if (id == 502001) return "[防具]一级头盔";
  }if (按钮.二级头) {
    if (id == 502002) return "[防具]二级头盔";
  }if (按钮.三级头) {
    if (id == 502003) return "[防具]三级头盔";
  }if (按钮.平底锅) {
    if (id == 108004) return "[近战]平底锅";
  }if (按钮.镰刀) {
    if (id == 108003) return "[近战]镰刀";
  }if (按钮.撬棍) {
    if (id == 108002) return "[近战]撬棍";
  }if (按钮.大砍刀) {
    if (id == 108001) return "[近战]大砍刀";
  }if (按钮.盾牌) {
    if (id == 107010) return "[防具]突击盾牌";
  }if (按钮.一级包) {
    if (id == 501001 || id == 501004 || id == 501007) return "[背包]一级包";
  }if (按钮.二级包) {
    if (id == 501002 || id == 501005 || id == 501008) return "[背包]二级包";
  }if (按钮.三级包) {
    if (id == 501003 || id == 501006 || id == 501009) return "[背包]三级包";
  }if (按钮.汽油) {
    if (id == 603001 || id == 603002) return "汽油";
  }if (按钮.吉利服) {
    if (id == 403990) return "[衣服]吉利服";
  }if (按钮.吉利服1) {
    if (id == 403187) return "[衣服]吉利服1";
  }if (按钮.R45双持) {
    if (id == 106005) return "[武器]R45双持";
  }if (按钮.沙漠之鹰) {
    if (id == 106010) return "[武器]沙漠之鹰";
  }if (按钮.TMP9) {
    if (id == 106011) return "[武器]TMP-9";
  }if (按钮.蝎式手枪) {
    if (id == 106008) return "[武器]蝎式手枪";
  }if (按钮.P18C) {
    if (id == 106004) return "[武器]P18C";
  }if (按钮.R1911) {
    if (id == 106002) return "[武器]R1911";
  }if (按钮.P92) {
    if (id == 106001) return "[武器]P92";
  }if (按钮.十字弩) {
    if (id == 107001) return "[武器]十字弩";
  }if (按钮.AWM) {
    if (id == 103003) return "[武器]AWM";
  }if (按钮.kar98k) {
    if (id == 103001) return "[武器]Kar98K";
  }if (按钮.M24) {
    if (id == 103002) return "[武器]M24";
  }if (按钮.Mini14) {
    if (id == 103006) return "[武器]Mini14";
  }if (按钮.Win94) {
    if (id == 103008) return "[武器]Win94";
  }if (按钮.SLR) {
    if (id == 103009) return "[武器]SLR";
  }if (按钮.AMR) {
    if (id == 103012) return "[武器]AMR狙击枪";
  }if (按钮.M417) {
    if (id == 103013) return "[武器]M417";
  }if (按钮.MK20) {
    if (id == 103014) return "[武器]MK20-H";
  }if (按钮.MK12) {
    if (id == 103100) return "[武器]MK12";
  }if (按钮.QBU) {
    if (id == 103010) return "[武器]QBU";
  }if (按钮.SKS) {
    if (id == 103004) return "[武器]SKS";
  }if (按钮.MK14) {
    if (id == 103007) return "[武器]MK14";
  }if (按钮.M200) {
    if (id == 103015) return "[武器]M200";
  }if (按钮.莫辛纳甘) {
    if (id == 103011) return "[武器]莫辛狙击枪";
  }if (按钮.爆炸猎弓) {
    if (id == 107007) return "[武器]爆炸猎弓";
  }if (按钮.蜜罐) {
    if (id == 101012) return "[武器]蜜獾";
  }if (按钮.M762) {
    if (id == 101008) return "[武器]M762";
  }if (按钮.VAL) {
    if (id == 101011) return "[武器]VC-VAL突击步枪";
  }if (按钮.G63C) {
    if (id == 101010) return "[武器]G36C步枪";
  }if (按钮.Famas) {
    if (id == 101013) return "[武器]Famas突击步枪";
  }if (按钮.DP28) {
    if (id == 105002) return "[武器]DP28";
  }if (按钮.狗砸) {
    if (id == 101005) return "[武器]狗砸";
  }if (按钮.AKM) {
    if (id == 101001) return "[武器]AKM";
  }if (按钮.QBZ) {
    if (id == 101007) return "[武器]QBZ";
  }if (按钮.MK47) {
    if (id == 101009) return "[武器]MK47";
  }if (按钮.AUG) {
    if (id == 101006) return "[武器]AUG";
  }if (按钮.M16A4) {
    if (id == 101002) return "[武器]M16A4";
  }if (按钮.SCAR) {
    if (id == 101003) return "[武器]SCAR";
  }if (按钮.M416) {
    if (id == 101004) return "[武器]M416";
  }if (按钮.M249) {
    if (id == 105001) return "[武器]M249";
  }if (按钮.PKM) {
    if (id == 105012) return "[武器]PKM";
  }if (按钮.MG3) {
    if (id == 105010) return "[武器]MG3";
  }if (按钮.UZI) {
    if (id == 102001) return "[武器]UZI";
  }if (按钮.汤姆逊) {
    if (id == 102004) return "[武器]汤姆逊冲锋枪";
  }if (按钮.维克托) {
    if (id == 102003) return "[武器]维克托";
  }if (按钮.UMP9) {
    if (id == 102002) return "[武器]UMP9";
  }if (按钮.VSS) {
    if (id == 103005) return "[武器]VSS射手步枪";
  }if (按钮.野牛) {
    if (id == 102005) return "[武器]野牛冲锋枪";
  }if (按钮.MP5K) {
    if (id == 102007) return "[武器]MP5K";
  }if (按钮.P90) {
    if (id == 102105) return "[武器]P90冲锋枪";
  }if (按钮.R1895) {
    if (id == 106003) return "[武器]R1895";
  }if (按钮.短管散弹枪) {
    if (id == 106006) return "[武器]短管散弹枪";
  }if (按钮.S12K) {
    if (id == 104003) return "[武器]S12K";
  }if (按钮.S1897) {
    if (id == 104002) return "[武器]S1897";
  }if (按钮.双管猎枪) {
    if (id == 104001) return "[武器]双管猎枪";
  }if (按钮.DBS) {
    if (id == 104004) return "[武器]DBS";
  }if (按钮.SPAS) {
    if (id == 104100) return "[武器]SPAS-12";
  }if (按钮.AA12) {
    if (id == 104005) return "[武器]AA12-G";
  }if (按钮.马格南) {
    if (id == 306001) return "[子弹]马格南";
  }if (按钮.A762) {
    if (id == 302001) return "[子弹]7.62MM";
  }if (按钮.A556) {
    if (id == 303001) return "[子弹]5.56MM";
  }if (按钮.A9毫米) {
    if (id == 301001) return "[子弹]9MM";
  }if (按钮.A12口径) {
    if (id == 304001) return "[子弹]12口径";
  }if (按钮.A45口径) {
    if (id == 305001) return "[子弹]45口径";
  }if (按钮.A57MM) {
    if (id == 301002) return "[子弹]5.7MM";
  }if (按钮.A50口径) {
    if (id == 306002) return "[子弹]50口径";
  }if (按钮.信号枪子弹) {
    if (id == 308001) return "[子弹]信号枪";
  }if (按钮.箭矢) {
    if (id == 307001) return "[子弹]箭矢";
  }if (按钮.红点) {
    if (id == 203001) return "[倍镜]红点";
  }if (按钮.全息) {
    if (id == 203002) return "[倍镜]全息";
  }if (按钮.二倍镜) {
    if (id == 203003) return "[倍镜]2倍镜";
  }if (按钮.三倍镜) {
    if (id == 203014) return "[倍镜]3倍镜";
  }if (按钮.四倍镜) {
    if (id == 203004) return "[倍镜]4倍镜";
  }if (按钮.六倍镜) {
    if (id == 203015) return "[倍镜]6倍镜";
  }if (按钮.八倍镜) {
    if (id == 203005) return "[倍镜]8倍镜";
  }if (按钮.侧面镜) {
    if (id == 203018) return "[倍镜]侧面镜";
  }if (按钮.战术瞄准镜) {
    if (id == 203030) return "[倍镜]战术瞄准镜";
  }if (按钮.子弹袋) {
    if (id == 204014) return "[配件]子弹袋";
  }if (按钮.箭袋) {
    if (id == 205004) return "[配件]箭袋";
  }if (按钮.子弹袋) {
    if (id == 204010) return "[配件]子弹袋";
  }if (按钮.激光瞄准镜) {
    if (id == 202007) return "[配件]激光瞄准器";
  }if (按钮.轻型握把) {
    if (id == 202004) return "[配件]轻型握把";
  }if (按钮.半载握把) {
    if (id == 202005) return "[配件]半截握把";
  }if (按钮.UZI枪托) {
    if (id == 205001) return "[配件]UZI枪托";
  }if (按钮.狙击枪托) {
    if (id == 205003) return "[配件]狙击枪托";
  }if (按钮.步枪枪托) {
    if (id == 205002) return "[配件]步枪枪托";
  }if (按钮.狙击补偿器) {
    if (id == 201003) return "[配件]狙击枪补偿器";
  }if (按钮.狙击枪消焰器) {
    if (id == 201005) return "[配件]狙击枪消焰器";
  }if (按钮.狙击枪消音器) {
    if (id == 201007) return "[配件]狙击枪消音器";
  }if (按钮.步枪消音器) {
    if (id == 201011) return "[配件]步枪消音器";
  }if (按钮.步枪补偿器) {
    if (id == 201009) return "[配件]步枪补偿器";
  }if (按钮.步枪消焰器) {
    if (id == 201010) return "[配件]步枪消焰器";
  }if (按钮.冲锋枪消音器) {
    if (id == 201006) return "[配件]冲锋枪消音器";
  }if (按钮.冲锋枪消焰器) {
    if (id == 201004) return "[配件]冲锋枪消焰器";
  }if (按钮.冲锋枪消焰器) {
    if (id == 201002) return "[配件]冲锋枪消焰器";
  }if (按钮.拇指握把) {
    if (id == 202006) return "[配件]拇指握把";
  }if (按钮.垂直握把) {
    if (id == 202002) return "[配件]垂直握把";
  }if (按钮.直角握把) {
    if (id == 202001) return "[配件]直角握把";
  }if (按钮.撞火枪托) {
    if (id == 205011) return "[配件]撞火枪托";
  }if (按钮.霰弹快速) {
    if (id == 204017) return "[配件]霰弹快速";
  }if (按钮.鸭嘴枪口) {
    if (id == 201012) return "[配件]鸭嘴枪口";
  }if (按钮.霰弹收束) {
    if (id == 201001) return "[配件]霰弹收束";
  }if (按钮.狙击枪快扩) {
    if (id == 204009) return "[配件]狙击枪快扩";
  }if (按钮.狙击枪扩容) {
    if (id == 204007) return "[配件]狙击枪扩容";
  }if (按钮.狙击枪快速) {
    if (id == 204008) return "[配件]狙击枪快速";
  }if (按钮.步枪快扩) {
    if (id == 204013) return "[配件]步枪快扩";
  }if (按钮.步枪扩容) {
    if (id == 204011) return "[配件]步枪扩容";
  }if (按钮.步枪快速) {
    if (id == 204012) return "[配件]步枪快速";
  }if (按钮.冲锋枪快扩) {
    if (id == 204006) return "[配件]冲锋枪快扩";
  }if (按钮.冲锋枪扩容) {
    if (id == 204004) return "[配件]冲锋枪扩容";
  }if (按钮.冲锋枪快速) {
    if (id == 204005) return "[配件]冲锋枪快速";
  }if (按钮.手枪快扩) {
    if (id == 204003) return "[配件]手枪快扩";
  }if (按钮.手枪快速) {
    if (id == 204002) return "[配件]手枪快速";
  }if (按钮.手枪扩容) {
    if (id == 204001) return "[配件]手枪扩容";
  }if (按钮.燃烧瓶) {
    if (id == 602003) return "[投掷]燃烧瓶";
  }if (按钮.烟雾弹) {
    if (id == 602002) return "[投掷]烟雾弹";
  }if (按钮.震爆弹) {
    if (id == 602001) return "[投掷]震爆弹";
  }if (按钮.手榴弹) {
    if (id == 602004) return "[投掷]手榴弹";
  }if (按钮.烟雾榴弹) {
    if (id == 307104) return "[手枪]烟雾榴弹";
  }
  return "Error";
}